const uniID = require('uni-id-common') // 引入uni-id-common
const db = uniCloud.database(); // 引入数据库
const $ = db.command.aggregate;

module.exports = {
	_before: async function() { // 通用预处理器
		const methodName = this.getMethodName(); // 获取当前调用的方法名
		const params = this.getParams(); // 获取当前参数列表
		const requestId = this.getUniCloudRequestId(); // 获取请求id
		this.token = await this.getUniIdToken(); // 获取用户token
		if (!this.token) {
			const error = new Error('用户未登录');
			error.code = 401; // 自定义错误码
			error.msg = '用户未登录'; // 自定义错误信息
			throw error;
		}


		const cloudInfo = this.getCloudInfo(); // 获取云端信息
		const clientInfo = this.getClientInfo(); // 获取客户端信息
		this.uniIDIns = await uniID.createInstance({ // 创建uni-id实例
			context: cloudInfo
		});
		this.userInfo = await this.uniIDIns.checkToken(this.token); // 获取用户信息
		if (this.userInfo.code == 30203 || !this.userInfo.uid) {
			const error = new Error('登录状态过期');
			error.code = 401; // 自定义错误码
			error.msg = '登录状态过期'; // 自定义错误信息
			throw error;
		}
		// console.log('User Data:', JSON.stringify(this.userInfo, null, 2)); // 更清晰地打印对象
	},
	/**
	 * 获取用户信息
	 * @returns {object} 返回用户信息
	 */
	async getUserInfo(user_id) {
		const res = await db.collection('uni-id-users').aggregate()
			.match({
				_id: user_id || this.userInfo.uid
			})
			.project({
				nickname: true,
				avatar_file: true,
				signature: true,
				homepage: true
			})
			.end();
		return {
			code: 200,
			data: res.data
		}
	},
	/**
	 * 查询对应用户的圈子数据
	 * @param {string} user_id:用户id
	 * @returns {object} 返回圈子数据
	 */
	async getUserCircleData(user_id) {
		// 关联用户表获取发布者昵称头像,关联活动表获取活动名称和图片，关联点赞表获取点赞数，关联评论表获取评论数
		const res = await db.collection('uni-cms-articles').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: user_id || this.userInfo.uid,
				audit_status: 1,
				article_status: 1
			})
			// 关联用户表获取发布者昵称头像
			.lookup({
				from: 'uni-id-users', //关联用户表
				localField: 'user_id', //关联的字段
				foreignField: '_id', //被关联的字段
				as: 'user_info' //存放用户信息的新字段
			})
			.lookup({
				from: 'qmy-activity', //关联活动表
				localField: 'activity_id', //关联的字段
				foreignField: '_id', //被关联的字段
				as: 'activity_info' //存放活动信息的新字段
			})
			.lookup({
				from: 'opendb-news-comments', //关联评论表
				localField: '_id', //关联的字段
				foreignField: 'article_id', //被关联的字段
				as: 'comment_info' //存放评论信息的新字段
			})
			.lookup({
				from: 'qmy-article-like', //关联点赞表
				localField: '_id', //关联的字段
				foreignField: 'article_id', //被关联的字段
				as: 'like_info' //存放点赞信息的新字段
			})
			.addFields({
				user_name: $.arrayElemAt(['$user_info.nickname', 0]), //取出字段里的发布者昵称
				user_avatar: $.arrayElemAt(['$user_info.avatar_file.url', 0]), //取出字段里的发布者头像
				user_gender: $.arrayElemAt(['$user_info.gender', 0]), //取出字段里的发布者性别
				activity_name: $.arrayElemAt(['$activity_info.name', 0]), //取出字段里的活动名称
				activity_img: $.arrayElemAt(['$activity_info.imgs', 0]), //取出字段里的活动图片
				like_user_id: '$like_info.user_id', //取出字段里的点赞用户id
				// comment_count: '$filtered_comments.user_id' //取出字段里的评论者的id
				comment_count: $.size($.filter({
					input: "$comment_info",
					as: "comment",
					cond: {
						$eq: ["$$comment.comment_type", 0]
					}
				}))
			})
			.project({
				user_info: false, //去除发布者用户数据，一定要去除，不然会输出发布者数据库里的所有用户数据
				activity_info: false, //去除活动数据
				like_info: false, //去除点赞数据
				comment_info: false, //去除评论数据
			}).sort({
				last_modify_date: -1
			})
			.limit(500).end();
		return {
			code: 200,
			data: res.data
		}
	},
	/**
	 * 查询自己的圈子数据
	 * @returns {object} 返回圈子数据
	 */
	async getMyCircleData(user_id) {
		// 关联用户表获取发布者昵称头像,关联活动表获取活动名称和图片，关联点赞表获取点赞数，关联评论表获取评论数
		const res = await db.collection('uni-cms-articles').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: user_id || this.userInfo.uid
			})
			// 关联用户表获取发布者昵称头像
			.lookup({
				from: 'uni-id-users', //关联用户表
				localField: 'user_id', //关联的字段
				foreignField: '_id', //被关联的字段
				as: 'user_info' //存放用户信息的新字段
			})
			.lookup({
				from: 'qmy-activity', //关联活动表
				localField: 'activity_id', //关联的字段
				foreignField: '_id', //被关联的字段
				as: 'activity_info' //存放活动信息的新字段
			})
			.lookup({
				from: 'opendb-news-comments', //关联评论表
				localField: '_id', //关联的字段
				foreignField: 'article_id', //被关联的字段
				as: 'comment_info' //存放评论信息的新字段
			})
			.lookup({
				from: 'qmy-article-like', //关联点赞表
				localField: '_id', //关联的字段
				foreignField: 'article_id', //被关联的字段
				as: 'like_info' //存放点赞信息的新字段
			})
			.addFields({
				user_name: $.arrayElemAt(['$user_info.nickname', 0]), //取出字段里的发布者昵称
				user_avatar: $.arrayElemAt(['$user_info.avatar_file.url', 0]), //取出字段里的发布者头像
				user_gender: $.arrayElemAt(['$user_info.gender', 0]), //取出字段里的发布者性别
				activity_name: $.arrayElemAt(['$activity_info.name', 0]), //取出字段里的活动名称
				activity_img: $.arrayElemAt(['$activity_info.imgs', 0]), //取出字段里的活动图片
				like_user_id: '$like_info.user_id', //取出字段里的点赞用户id
				// comment_count: '$filtered_comments.user_id' //取出字段里的评论者的id
				comment_count: $.size($.filter({
					input: "$comment_info",
					as: "comment",
					cond: {
						$eq: ["$$comment.comment_type", 0]
					}
				}))
			})
			.project({
				user_info: false, //去除发布者用户数据，一定要去除，不然会输出发布者数据库里的所有用户数据
				activity_info: false, //去除活动数据
				like_info: false, //去除点赞数据
				comment_info: false, //去除评论数据
			}).sort({
				last_modify_date: -1
			})
			.limit(500).end();
		return {
			code: 200,
			data: res.data
		}
	},

	/**
	 * 获取自己的圈子详情，不限制审核是否通过
	 * @param {string} id:圈子id
	 * @returns {object} 返回圈子详情
	 */
	async getMyCircleDetail(id) {
		if (!id) {
			let error = new Error('请求参数错误');
			error.code = 400;
			throw error;
		}
		const res = await db.collection('uni-cms-articles').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				_id: id, //条件查询
				user_id: this.userInfo.uid
			})
			.lookup({
				from: 'uni-id-users', //关联用户表
				localField: 'user_id', //关联的字段
				foreignField: '_id', //被关联的字段
				as: 'user_info' //存放用户信息的新字段
			})
			.lookup({
				from: 'qmy-activity', //关联活动表
				localField: 'activity_id', //关联的字段
				foreignField: '_id', //被关联的字段
				as: 'activity_info' //存放活动信息的新字段
			})
			.lookup({
				from: 'qmy-activity-sign-up', //关联报名表
				localField: 'activity_id', //关联的字段
				foreignField: 'activity_id', //被关联的字段
				as: 'sign_up_info' //存放报名信息的新字段
			})
			.lookup({
				from: 'qmy-article-like', //关联点赞表
				localField: '_id', //关联的字段
				foreignField: 'article_id', //被关联的字段
				as: 'like_info' //存放点赞信息的新字段
			})
			.addFields({
				user_name: $.arrayElemAt(['$user_info.nickname', 0]), //取出字段里的发布者昵称
				user_avatar: $.arrayElemAt(['$user_info.avatar_file.url', 0]), //取出字段里的发布者头像
				activity_name: $.arrayElemAt(['$activity_info.name', 0]), //取出字段里的活动名称
				activity_img: $.arrayElemAt(['$activity_info.imgs', 0]), //取出字段里的活动图片
				sign_up: $.filter({
					input: '$sign_up_info',
					as: 'item',
					cond: $.eq(['$$item.signup_status', 0])
				}), //取出字段里的报名状态为0：已报名的数据
				like_user_id: '$like_info.user_id', //取出字段里的点赞用户id
			})
			.addFields({
				sign_up_count: $.size('$sign_up') //获取报名数据长度得到报名人数
			})
			.project({
				user_info: false, //去除发布者用户数据，一定要去除，不然会输出发布者数据库里的所有用户数据
				activity_info: false, //去除活动数据
				sign_up_info: false, //去除报名数据
				sign_up: false, //去除报名数据
				last_modify_ip: false, //去除修改ip
				publish_ip: false, //去除发布ip
				like_info: false, //去除点赞数据
			}).end();
		return {
			code: 200,
			data: res.data
		}
	},

	/**
	 * 查询对应用户的活动数据
	 * @returns {object} 返回活动数据
	 */
	async getUserActivityData(user_id) {
		const res = await db.collection('qmy-activity').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: user_id || this.userInfo.uid,
				audit_status: 1
			})
			// 关联活动表和报名表
			.lookup({
				from: 'qmy-activity-sign-up', // 报名表
				localField: '_id', // 当前表活动表的字段
				foreignField: 'activity_id', // 报名表中的活动ID字段
				as: 'sign_up_info' // 将关联数据放到 sign_up_info 字段中
			})
			.addFields({
				sign_up: $.filter({
					input: '$sign_up_info',
					as: 'item',
					cond: $.eq(['$$item.signup_status', 0])
				}), //取出字段里的报名状态为0：已报名的数据
			})
			// 关联报名表和用户表
			.lookup({
				from: 'uni-id-users', // 用户表
				localField: 'sign_up.user_id', // 报名表中的用户ID字段
				foreignField: '_id', // 用户表中的用户ID字段
				as: 'user_info' // 将关联数据放到 user_info 字段中
			})
			// 取出user_info里的用户id、昵称、头像到新数组里
			.addFields({
				user_info: $.map({
					input: '$user_info',
					as: 'item',
					in: {
						user_id: '$$item._id',
						user_name: '$$item.nickname',
						user_avatar: '$$item.avatar_file.url'
					}
				})
			})
			.project({
				sign_up_info: false,
				sign_up: false
			})
			.sort({
				sort: 1,
				signup_start_time: -1,
				start_time: -1
			})
			.limit(500)
			.end();

		return {
			code: 200,
			data: res.data
		}
	},
	/**
	 * 查询自己的活动列表，不限制审核是否通过
	 * @returns {object} 返回活动数据
	 */
	async getMyActivityData() {
		const res = await db.collection('qmy-activity').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: this.userInfo.uid,
			})
			// 关联活动表和报名表
			.lookup({
				from: 'qmy-activity-sign-up', // 报名表
				localField: '_id', // 当前表活动表的字段
				foreignField: 'activity_id', // 报名表中的活动ID字段
				as: 'sign_up_info' // 将关联数据放到 sign_up_info 字段中
			})
			.addFields({
				sign_up: $.filter({
					input: '$sign_up_info',
					as: 'item',
					cond: $.eq(['$$item.signup_status', 0])
				}), //取出字段里的报名状态为0：已报名的数据
			})
			// 关联报名表和用户表
			.lookup({
				from: 'uni-id-users', // 用户表
				localField: 'sign_up.user_id', // 报名表中的用户ID字段
				foreignField: '_id', // 用户表中的用户ID字段
				as: 'user_info' // 将关联数据放到 user_info 字段中
			})
			// 取出user_info里的用户id、昵称、头像到新数组里
			.addFields({
				user_info: $.map({
					input: '$user_info',
					as: 'item',
					in: {
						user_id: '$$item._id',
						user_name: '$$item.nickname',
						user_avatar: '$$item.avatar_file.url'
					}
				})
			})
			.project({
				sign_up_info: false,
				sign_up: false
			})
			.sort({
				sort: 1,
				signup_start_time: -1,
				start_time: -1
			})
			.limit(500)
			.end();

		return {
			code: 200,
			data: res.data
		}
	},
	/**
	 * 获取对应用户的活动数量
	 * @returns {object} 返回对应用户的活动数量
	 */
	async getMyActivityCount(user_id) {
		const countRes = await db.collection('qmy-activity').where({
			user_id: user_id || this.userInfo.uid,
			audit_status: 1
		}).count();
		return {
			code: 200,
			data: countRes.total || 0
		}
	},
	/**
	 * 获取对应用户的圈子点赞数
	 * @returns {object} 返回对应用户的圈子点赞数
	 */
	async getMyCircleLikeCount(user_id) {
		const totalLikesRes = await db.collection('uni-cms-articles').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: user_id || this.userInfo.uid,
				audit_status: 1,
				article_status: 1
			})
			.lookup({
				from: 'qmy-article-like',
				localField: '_id',
				foreignField: 'article_id',
				as: 'like_info'
			})
			// 先计算每篇文章的点赞数
			.addFields({
				like_count: {
					$size: "$like_info"
				}
			})
			// 统计所有文章的点赞总数
			.group({
				_id: null, // 聚合所有文章
				total_likes: {
					$sum: "$like_count"
				}
			})
			.end();
		// 获取总点赞数
		const totalLikes = totalLikesRes.data.length > 0 ? totalLikesRes.data[0].total_likes : 0;
		return {
			code: 200,
			data: totalLikes // 防止 undefined
		};
	},
	/**
	 * 查询对应用户的圈子（文章）数量
	 * @returns {object} 返回我的圈子数量
	 */
	async getMyCircleCount(user_id) {
		const countRes = await db.collection('uni-cms-articles')
			.where({
				user_id: user_id || this.userInfo.uid, // 仅查询当前用户的文章
				article_status: 1,
				audit_status: 1
			})
			.count(); // 直接统计数量

		return {
			code: 200,
			data: countRes.total || 0 // 返回文章总数，防止 undefined
		};
	},
	/**
	 * 获取我的报名数据
	 * @returns {object} 返回我的报名数据
	 */
	async getMySignUpData() {
		const res = await db.collection('qmy-activity-sign-up').aggregate()
			// 先筛选当前用户的报名信息，提高查询效率
			.match({
				user_id: this.userInfo.uid,
				signup_status: 0
			})
			// 关联活动信息
			.lookup({
				from: 'qmy-activity',
				localField: 'activity_id',
				foreignField: '_id',
				as: 'activity_info'
			})
			// 过滤掉删除活动的报名数据
			.match({
				'activity_info': {
					$ne: []
				}
			})
			// 过滤掉未审核通过的活动
			.match({
				'activity_info.audit_status': 1
			})
			// 关联报名用户信息
			.lookup({
				from: 'qmy-activity-sign-up',
				localField: 'activity_info._id',
				foreignField: 'activity_id',
				as: 'sign_up_info'
			})
			// 仅保留 `sign_up_info` 里 status=0 的数据
			.addFields({
				sign_up_info: $.filter({
					input: '$sign_up_info',
					as: 'signUp',
					cond: $.eq(['$$signUp.signup_status', 0])
				})
			})
			// 关联用户表获取报名用户的头像和昵称加入到对应的sign_up_info里，没有头像昵称的设置默认值
			.lookup({
				from: 'uni-id-users',
				localField: 'sign_up_info.user_id',
				foreignField: '_id',
				as: 'user_info'
			})
			// 取出user_info里的用户id、昵称、头像到新数组里
			.addFields({
				user_info: $.map({
					input: '$user_info',
					as: 'item',
					in: {
						user_id: '$$item._id',
						user_name: '$$item.nickname',
						user_avatar: '$$item.avatar_file.url'
					}
				})
			})

			// 限制返回数据，避免查询超时
			.limit(500)
			.end();
		return {
			code: 200,
			data: res.data
		};
	},
	/**
	 * 获取我的报名的活动数量，统计进行中和已结束的活动数量
	 * @returns {object} 返回进行中和已结束的活动数量
	 */
	async getMySignUpCount() {
		const now = Date.now(); // 获取当前时间戳

		const res = await db.collection('qmy-activity-sign-up').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: this.userInfo.uid,
				signup_status: 0
			})
			// 关联活动表
			.lookup({
				from: 'qmy-activity',
				localField: 'activity_id',
				foreignField: '_id',
				as: 'activity_info'
			})
			// 去掉已删除的活动
			.match({
				'activity_info': {
					$ne: []
				}
			})
			.sort({
				signup_time: -1
			})
			.limit(500)
			.end();

		// 初始化计数器
		let ongoingCount = 0; // 进行中活动
		let endedCount = 0; // 已结束活动

		res.data.forEach(item => {
			const activity = item.activity_info[0] || {}; // 获取活动信息
			if (activity.start_time && activity.end_time) {
				const startTime = new Date(activity.start_time).getTime();
				const endTime = new Date(activity.end_time).getTime();

				if (now >= startTime && now <= endTime) {
					ongoingCount++; // 进行中
				} else if (now > endTime) {
					endedCount++; // 已结束
				}
			}
		});

		return {
			code: 200,
			data: {
				ongoing: ongoingCount,
				ended: endedCount
			}
		};
	},
	/**
	 * 获取圈子通知列表
	 * @returns {object} 返回圈子通知列表
	 */
	async getCircleNoticeList() {
		// 首先拿到所有文章的点赞和评论数据
		const res = await db.collection('uni-cms-articles').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: this.userInfo.uid
			})
			// 关联点赞表,获取文章点赞数据
			.lookup({
				from: 'qmy-article-like',
				localField: '_id',
				foreignField: 'article_id',
				as: 'like_info'
			})
			//往点赞数据里添加对应的文章数据
			.addFields({
				like_info: $.map({
					input: "$like_info",
					as: "like",
					in: $.mergeObjects(["$$like", {
						article_data: "$$ROOT"
					}])
				})
			})
			// 关联评论表，获取文章评论数据，去掉对评论的回复
			.lookup({
				from: 'opendb-news-comments',
				localField: '_id',
				foreignField: 'article_id',
				as: 'comment_info'
			})
			// 筛选掉评论表中comment_type等于1的数据，去掉对评论的回复
			.addFields({
				comment_info: $.filter({
					input: "$comment_info",
					as: "comment",
					cond: {
						$ne: ["$$comment.comment_type", 1]
					}
				})
			})
			// 往评论数据里添加对应的文章数据
			.addFields({
				comment_info: $.map({
					input: "$comment_info",
					as: "comment",
					in: $.mergeObjects(["$$comment", {
						article_data: "$$ROOT"
					}])
				})
			})
			// 整合后的评论点赞数据
			.addFields({
				all_interactions: $.concatArrays(["$like_info", "$comment_info"])
			})
			// 整合后的评论点赞数据关联用户表
			.lookup({
				from: 'uni-id-users',
				localField: 'all_interactions.user_id',
				foreignField: '_id',
				as: 'comment_like_user_info'
			})
			// 处理 all_interactions 数据，关联用户昵称和头像
			.addFields({
				all_data: $.map({
					input: "$all_interactions",
					as: "interaction",
					in: $.mergeObjects([
						"$$interaction", // 保留原来的互动数据
						{
							// 获取对应的用户信息（昵称）
							user_name: $.cond({
								if: {
									$gt: [{
										$size: "$comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$interaction.user_id"
												])
											}),
											0
										])
									},
									in: $.ifNull(["$$user.nickname",
										null
									]) // 用户昵称，若无则为 null
								}),
								else: null
							}),
							// 获取对应的用户信息（头像）
							user_avatar: $.cond({
								if: {
									$gt: [{
										$size: "$comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$interaction.user_id"
												])
											}),
											0
										])
									},
									in: $.ifNull(["$$user.avatar_file.url",
										null
									]) // 用户头像，若无则为 null
								}),
								else: null
							}),
							// 获取对应的用户信息（性别）
							user_gender: $.cond({
								if: {
									$gt: [{
										$size: "$comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$interaction.user_id"
												])
											}),
											0
										])
									},
									in: $.ifNull(["$$user.gender",
										null
									]) // 用户性别，若无则为 null
								}),
								else: null
							})
						}
					])
				})
			})
			// 去掉不需要的数据
			.project({
				like_info: false,
				comment_like_user_info: false,
				comment_info: false,
				all_interactions: false
			})
			.end();


		// 查找评论表中所有我的评论
		const likeRes = await db.collection('opendb-news-comments').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: this.userInfo.uid
			})
			// 关联点赞表获取点赞数据
			.lookup({
				from: 'qmy-article-like',
				localField: '_id',
				foreignField: 'comment_id',
				as: 'comment_like_info'
			})
			// 往点赞数据里添加对应的评论数据
			.addFields({
				comment_like_info: $.map({
					input: "$comment_like_info",
					as: "like",
					in: $.mergeObjects(["$$like", {
						like_data: "$$ROOT"
					}])
				})
			})
			// 点赞数据关联用户表获取点赞用户的id、头像、昵称
			.lookup({
				from: 'uni-id-users',
				localField: 'comment_like_info.user_id',
				foreignField: '_id',
				as: 'comment_like_user_info'
			})
			// 往点赞数据里加入用户id、头像、昵称,comment_like_user_info是数组，不能直接加，需要对应comment_like_info的user_id和comment_like_user_info的_id
			.addFields({
				all_data: $.map({
					input: "$comment_like_info",
					as: "like",
					in: $.mergeObjects([
						"$$like", // 保留原点赞数据
						{
							// 获取点赞用户的昵称，匹配 user_id 和 user_info._id
							user_name: $.cond({
								if: {
									$gt: [{
										$size: "$comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$like.user_id"
												]) // 根据 user_id 匹配用户
											}),
											0
										])
									},
									in: $.ifNull(["$$user.nickname", null])
								}),
								else: null
							}),
							// 获取点赞用户的头像，匹配 user_id 和 user_info._id
							user_avatar: $.cond({
								if: {
									$gt: [{
										$size: "$comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$like.user_id"
												]) // 根据 user_id 匹配用户
											}),
											0
										])
									},
									in: $.ifNull(["$$user.avatar_file.url",
										null
									])
								}),
								else: null
							}),
							// 获取点赞用户的性别，匹配 user_id 和 user_info._id、
							user_gender: $.cond({
								if: {
									$gt: [{
										$size: "$comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$like.user_id"
												]) // 根据 user_id 匹配用户
											}),
											0
										])
									},
									in: $.ifNull(["$$user.gender",
										null
									])
								}),
								else: null
							}),
						}
					])
				})
			})
			.project({
				comment_like_user_info: false,
				comment_like_info: false
			})
			.end();


		// 查询评论表中我所有的评论
		const commentRes = await db.collection('opendb-news-comments').aggregate()
			.match({
				user_id: this.userInfo.uid
			})
			// 关联评论表，获取评论的回复数据
			.lookup({
				from: 'opendb-news-comments',
				localField: '_id',
				foreignField: 'reply_comment_id',
				as: 'reply_comment_info'
			})
			// 往回复数据里添加对应的评论数据
			.addFields({
				reply_comment_info: $.map({
					input: "$reply_comment_info",
					as: "reply",
					in: $.mergeObjects(["$$reply", {
						comment_data: "$$ROOT"
					}])
				})
			})
			// 整合后的回复点赞数据关联用户表获取点赞用户的id、头像、昵称
			.lookup({
				from: 'uni-id-users',
				localField: 'reply_comment_info.user_id',
				foreignField: '_id',
				as: 'reply_comment_like_user_info'
			})
			// 往点赞数据里加入用户id、头像、昵称，处理数组，避免直接加
			.addFields({
				all_data: $.map({
					input: "$reply_comment_info", // 处理回复数据
					as: "reply",
					in: $.mergeObjects([
						"$$reply", // 保留原回复数据
						{
							user_name: $.cond({
								if: {
									$gt: [{
										$size: "$reply_comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$reply_comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$reply.user_id"
												]) // 匹配 user_id
											}),
											0
										])
									},
									in: "$$user.nickname" // 返回昵称
								}),
								else: null // 如果没有用户信息则不返回昵称
							}),
							user_avatar: $.cond({
								if: {
									$gt: [{
										$size: "$reply_comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$reply_comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$reply.user_id"
												]) // 匹配 user_id
											}),
											0
										])
									},
									in: "$$user.avatar_file.url" // 返回头像 URL
								}),
								else: null // 如果没有用户信息则不返回头像
							}),
							user_gender: $.cond({
								if: {
									$gt: [{
										$size: "$reply_comment_like_user_info"
									}, 0]
								},
								then: $.let({
									vars: {
										user: $.arrayElemAt([
											$.filter({
												input: "$reply_comment_like_user_info",
												as: "user",
												cond: $.eq(["$$user._id",
													"$$reply.user_id"
												]) // 匹配 user_id
											}),
											0
										])
									},
									in: "$$user.gender" // 返回性别 URL
								}),
								else: null // 如果没有用户信息则不返回性别
							}),
						}
					])
				})
			})
			.project({
				reply_comment_like_user_info: false,
				reply_comment_info: false
			})
			.end();
		// 获取最大长度
		const maxLength = Math.max(res.data.length, likeRes.data.length, commentRes.data.length);
		// 合并所有的 all_data 元素
		const mergedData = [];
		// 遍历 res、likeRes、commentRes 的数据，按顺序合并它们的 all_data 数组
		const dataArrays = [res.data, likeRes.data, commentRes.data];
		for (let i = 0; i < dataArrays.length; i++) {
			// 遍历每个数组，获取 all_data 数组并合并
			dataArrays[i].forEach(item => {
				// 如果 all_data 存在，合并它的内容
				if (item.all_data && item.all_data.length > 0) {
					mergedData.push(...item.all_data);
				}
			});
		}
		mergedData.sort((a, b) => new Date(b.create_date) - new Date(a.create_date));
		return {
			code: 200,
			data: mergedData
		};
	},
	/**
	 * 获取活动通知列表
	 * @returns {object} 返回活动通知列表
	 */
	async getActivityNoticeList() {
		// 查询报名表获取自己参数的所有活动
		const res = await db.collection('qmy-activity-sign-up').aggregate()
			// 先进行条件查询，节省数据量，提高数据查询处理效率
			.match({
				user_id: this.userInfo.uid, // 用户id
				signup_status: 0 // 报名状态
			})
			// 关联活动表获取活动数据
			.lookup({
				from: 'qmy-activity',
				localField: 'activity_id',
				foreignField: '_id',
				as: 'activity_info'
			})
			// 过滤掉已经删除的活动数据
			.match({
				'activity_info': {
					$ne: []
				}
			})
			// 过滤掉未审核通过的活动数据
			.match({
				'activity_info.audit_status': 1
			})
			// 关联通知表获取每个活动的通知数据
			.lookup({
				from: 'qmy-notice',
				localField: 'activity_info._id',
				foreignField: 'activity_id',
				as: 'notice_info'
			})
			// 过滤掉未审核通过的通知数据
			.match({
				'notice_info.activity_audit_status': 1
			})
			// 关联用户表获取活动发布者的昵称和头像
			.lookup({
				from: 'uni-id-users',
				localField: 'activity_info.user_id',
				foreignField: '_id',
				as: 'user_info'
			})
			// 将用户信息合并到 activity_info，添加默认头像和昵称
			.addFields({
				activity_info: {
					$map: {
						input: "$activity_info",
						as: "activity",
						in: {
							$mergeObjects: [
								"$$activity", // 继承原活动数据
								{
									publisher_nickname: {
										$let: {
											vars: {
												nickname: {
													$ifNull: [{
															$arrayElemAt: ["$user_info.nickname", 0]
														},
														"" // 防止 missing
													]
												}
											},
											in: {
												$cond: {
													if: {
														$or: [{
																$eq: ["$$nickname", null]
															},
															{
																$eq: [{
																	$strLenBytes: "$$nickname"
																}, 0]
															}
														]
													},
													then: "匿名用户",
													else: "$$nickname"
												}
											}
										}
									},
									publisher_avatar: {
										$let: {
											vars: {
												avatar: {
													$ifNull: [{
															$arrayElemAt: [
																"$user_info.avatar_file.url", 0
															]
														},
														"" // 防止 missing
													]
												}
											},
											in: {
												$cond: {
													if: {
														$or: [{
																$eq: ["$$avatar", null]
															},
															{
																$eq: [{
																	$strLenBytes: "$$avatar"
																}, 0]
															}
														]
													},
													then: "https://mp-22f314fc-fd0f-43b9-886e-ac79fe32303c.cdn.bspapp.com/image/default-avatar.jpg",
													else: "$$avatar"
												}
											}
										}
									},
									publisher_gender: {
										$let: {
											vars: {
												gender: {
													$ifNull: [{ $arrayElemAt: ["$user_info.gender", 0] }, 0]
												}
											},
											in: {
												$cond: {
													if: { $eq: ["$$gender", null] }, // 直接判断是否 null
													then: 0, // 默认 0
													else: "$$gender"
												}
											}
										}
									}									
								}
							]
						}
					}
				}
			})
			.project({
				user_info: false
			})
			.limit(500)
			.end();
		let noticeList = [];

		res.data.forEach(item => {
			// 获取当前报名信息关联的活动
			const activity = item.activity_info[0] || {};

			// 遍历活动的通知列表
			item.notice_info.forEach(notice => {
				// 筛选出 activity_audit_status 为 1 审核通过的通知数据
				if (notice.activity_audit_status === 1) {
					noticeList.push({
						...notice, // 通知的原始信息
						activity_info: activity // 关联的活动信息
					});
				}
			});
		});
		noticeList.sort((a, b) => new Date(b.notice_time || 0) - new Date(a.notice_time || 0));

		return {
			code: 200,
			data: noticeList
		};
	},
	/**
	 * 获取系统通知列表
	 * @returns {object} 返回系统通知列表
	 */
	async getSystemNoticeList() {
		const res = await db.collection('qmy-notice').where({
			notice_type: 0,
			receive_user_id: this.userInfo.uid
		}).orderBy('user_read_status', 'asc').orderBy('notice_time', 'desc').limit(500).get();
		return {
			code: 200,
			data: res.data
		};
	},
	/**
	 * 获取用于编辑的活动详情，不限制是否审核成功
	 * @param {string} activityId:活动id
	 * @returns {object} 返回活动详情
	 */
	async getActivityDetailForEdit(activityId) {
		const res = await db.collection('qmy-activity').where({
			_id: activityId,
			user_id: this.userInfo.uid
		}).get();
		return {
			code: 200,
			data: res.data
		};
	},
	/**
	 * 获取用户余额记录
	 * @returns {object} 返回用户余额记录，最新一条记录里的余额为用户当前余额
	 */
	async getMyWalletData(timeRange) {
		const now = new Date();
		const dayOfWeek = now.getDay() || 7; // 0 代表周日，转换成 7
		const startOfWeek = new Date(now);
		startOfWeek.setDate(now.getDate() - dayOfWeek + 1); // 本周一
		startOfWeek.setHours(0, 0, 0, 0);
		const endOfWeek = new Date(startOfWeek);
		endOfWeek.setDate(startOfWeek.getDate() + 6); // 本周日
		endOfWeek.setHours(23, 59, 59, 999);

		const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
		const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0);
		endOfMonth.setHours(23, 59, 59, 999);

		const startOfYear = new Date(now.getFullYear(), 0, 1);
		const endOfYear = new Date(now.getFullYear(), 11, 31);
		endOfYear.setHours(23, 59, 59, 999);

		// ** 查询最新 500 条记录 **
		const res = await db.collection('qmy-user-wallet')
			.where({ user_id: this.userInfo.uid })
			.orderBy('create_date', 'desc')
			.limit(500)
			.get();

		// ** 计算收入和支出 **
		let totalIncome = 0, totalExpense = 0;
		res.data.forEach(item => {
			if (item.type === 1) totalIncome += item.money;
			if (item.type === 2) totalExpense += item.money;
		});

		// ** 颜色数组 **
		const colorArray = ['#14cc60', '#5B8FF9', '#5AD8A6', '#F6BD16', '#6F5EF9', '#946639', '#7235DA', '#F67046'];

		// ** 查询消费统计 **
		const chartData = await db.collection('qmy-user-wallet').aggregate()
			.match({
				user_id: this.userInfo.uid,
				type: 2,
				create_date: timeRange === 'week' ? { $gte: startOfWeek.getTime(), $lte: endOfWeek.getTime() }
					: timeRange === 'month' ? { $gte: startOfMonth.getTime(), $lte: endOfMonth.getTime() }
					: { $gte: startOfYear.getTime(), $lte: endOfYear.getTime() }
			})
			.group({ _id: '$comment', total: $.sum('$money') })
			.end();

		// ** 处理图表数据 **
		chartData.data.forEach((item, index) => {
			item.color = colorArray[index % colorArray.length] || `#${Math.floor(Math.random() * 16777215).toString(16)}`;
			item.name = item._id;
			item.value = item.total;
		});

		return {
			code: 200,
			data: {
				data: res.data,
				totalIncome,
				totalExpense,
				chartData: chartData.data
			}
		};
	},
	/**
	 * 单独获取最新一条余额记录
	 * @returns {object} 返回最新一条余额记录
	 */
	async getUserBalance() {
		const res = await db.collection('qmy-user-wallet').where({ user_id: this.userInfo.uid }).orderBy('create_date', 'desc').limit(1).get();
		return {
			code: 200,
			data: res.data
		};
	}

}